home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / edit / thesrc20.zip / rexx.c < prev    next >
C/C++ Source or Header  |  1995-01-26  |  35KB  |  811 lines
  1. /***********************************************************************/
  2. /* REXX.C - REXX interface routines.                                   */
  3. /***********************************************************************/
  4. /*
  5.  * THE - The Hessling Editor. A text editor similar to VM/CMS xedit.
  6.  * Copyright (C) 1991-1995 Mark Hessling
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License as
  10.  * published by the Free Software Foundation; either version 2 of
  11.  * the License, or any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16.  * General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to:
  20.  *
  21.  *    The Free Software Foundation, Inc.
  22.  *    675 Mass Ave,
  23.  *    Cambridge, MA 02139 USA.
  24.  *
  25.  *
  26.  * If you make modifications to this software that you feel increases
  27.  * it usefulness for the rest of the community, please email the
  28.  * changes, enhancements, bug fixes as well as any and all ideas to me.
  29.  * This software is going to be maintained and enhanced as deemed
  30.  * necessary by the community.
  31.  *
  32.  * Mark Hessling                     email: M.Hessling@gu.edu.au
  33.  * 36 David Road                     Phone: +61 7 849 7731
  34.  * Holland Park                      Fax:   +61 7 875 5314
  35.  * QLD 4121
  36.  * Australia
  37.  */
  38.  
  39. /*
  40. $Id: rexx.c 2.0 1995/01/26 16:31:55 MH Release MH $
  41. */
  42.  
  43. #if defined(PROTO)
  44. /*--------------------------- global data -----------------------------*/
  45. /* these are here because EMX include REXX definitions from within os2.h */
  46. /*---------------------------------------------------------------------*/
  47. #  define INCL_RXSUBCOM       /* Subcommand handler values */
  48. #  define INCL_RXSHV          /* Shared variable support */
  49. #  define INCL_RXSYSEXIT      /* System exit routines */
  50. #  define INCL_DOSPROCESS     /* Process/Thread Info */
  51. #  define INCL_RXFUNC         /* External functions */
  52.  
  53. #include "the.h"
  54. #include "proto.h"
  55. #include "query.h"
  56. #include "rexx.h"
  57.  
  58. #if defined(USE_AIXREXX)
  59. LONG THE_Commands(PRXSTRING, PUSHORT,PRXSTRING);
  60. LONG THE_Exit_Handler(LONG, LONG, PEXIT);
  61. USHORT THE_Function_Handler(PSZ,ULONG,PRXSTRING,PSZ,PRXSTRING);
  62. #else
  63. RexxSubcomHandler THE_Commands;
  64. RexxExitHandler THE_Exit_Handler;
  65. RexxFunctionHandler THE_Function_Handler;
  66. #endif
  67.  
  68. FILE *rexxoutfp;
  69. static LINETYPE captured_lines;
  70. static bool rexx_halted;
  71.  
  72.  
  73. struct function_item
  74.  {
  75.   CHARTYPE *name;                      /* name of item */
  76.   short item_number;                  /* unique number for item */
  77.   short item_index;                  /* index value for the whole item */
  78.   CHARTYPE query;                         /* valid query response ? */
  79.  };
  80. typedef struct function_item FUNCTION_ITEM;
  81.  
  82.  static FUNCTION_ITEM function_item[] =
  83.   {
  84.    {(CHARTYPE *)"ALT.0",ITEM_ALT,0,QUERY_FUNCTION},
  85.    {(CHARTYPE *)"ALT.1",ITEM_ALT,1,QUERY_FUNCTION},
  86.    {(CHARTYPE *)"ALT.2",ITEM_ALT,2,QUERY_FUNCTION},
  87.    {(CHARTYPE *)"ARBCHAR.0",ITEM_ARBCHAR,0,QUERY_FUNCTION},
  88.    {(CHARTYPE *)"ARBCHAR.1",ITEM_ARBCHAR,1,QUERY_FUNCTION},
  89.    {(CHARTYPE *)"ARBCHAR.2",ITEM_ARBCHAR,2,QUERY_FUNCTION},
  90.    {(CHARTYPE *)"AUTOSAVE.0",ITEM_AUTOSAVE,0,QUERY_FUNCTION},
  91.    {(CHARTYPE *)"AUTOSAVE.1",ITEM_AUTOSAVE,1,QUERY_FUNCTION},
  92.    {(CHARTYPE *)"BACKUP.0",ITEM_BACKUP,0,QUERY_FUNCTION},
  93.    {(CHARTYPE *)"BACKUP.1",ITEM_BACKUP,1,QUERY_FUNCTION},
  94.    {(CHARTYPE *)"BEEP.0",ITEM_BEEP,0,QUERY_FUNCTION},
  95.    {(CHARTYPE *)"BEEP.1",ITEM_BEEP,1,QUERY_FUNCTION},
  96.    {(CHARTYPE *)"BLOCK.0",ITEM_BLOCK,0,QUERY_FUNCTION},
  97.    {(CHARTYPE *)"BLOCK.1",ITEM_BLOCK,1,QUERY_FUNCTION},
  98.    {(CHARTYPE *)"BLOCK.2",ITEM_BLOCK,2,QUERY_FUNCTION},
  99.    {(CHARTYPE *)"BLOCK.3",ITEM_BLOCK,3,QUERY_FUNCTION},
  100.    {(CHARTYPE *)"BLOCK.4",ITEM_BLOCK,4,QUERY_FUNCTION},
  101.    {(CHARTYPE *)"BLOCK.5",ITEM_BLOCK,5,QUERY_FUNCTION},
  102.    {(CHARTYPE *)"BLOCK.6",ITEM_BLOCK,6,QUERY_FUNCTION},
  103.    {(CHARTYPE *)"CASE.0",ITEM_CASE,0,QUERY_FUNCTION},
  104.    {(CHARTYPE *)"CASE.1",ITEM_CASE,1,QUERY_FUNCTION},
  105.    {(CHARTYPE *)"CASE.2",ITEM_CASE,2,QUERY_FUNCTION},
  106.    {(CHARTYPE *)"CASE.3",ITEM_CASE,3,QUERY_FUNCTION},
  107.    {(CHARTYPE *)"CASE.4",ITEM_CASE,4,QUERY_FUNCTION},
  108.    {(CHARTYPE *)"CLEARSCREEN.0",ITEM_CLEARSCREEN,0,QUERY_FUNCTION},
  109.    {(CHARTYPE *)"CLEARSCREEN.1",ITEM_CLEARSCREEN,1,QUERY_FUNCTION},
  110.    {(CHARTYPE *)"CLOCK.0",ITEM_CLOCK,0,QUERY_FUNCTION},
  111.    {(CHARTYPE *)"CLOCK.1",ITEM_CLOCK,1,QUERY_FUNCTION},
  112.    {(CHARTYPE *)"CMDARROWS.0",ITEM_CMDARROWS,0,QUERY_FUNCTION},
  113.    {(CHARTYPE *)"CMDARROWS.1",ITEM_CMDARROWS,1,QUERY_FUNCTION},
  114.    {(CHARTYPE *)"CMDLINE.0",ITEM_CMDLINE,0,QUERY_FUNCTION},
  115.    {(CHARTYPE *)"CMDLINE.1",ITEM_CMDLINE,1,QUERY_FUNCTION},
  116.    {(CHARTYPE *)"CMDLINE.2",ITEM_CMDLINE,2,QUERY_FUNCTION},
  117.    {(CHARTYPE *)"CMDLINE.3",ITEM_CMDLINE,3,QUERY_FUNCTION},
  118.    {(CHARTYPE *)"COMPAT.0",ITEM_COMPAT,0,QUERY_FUNCTION},
  119.    {(CHARTYPE *)"COMPAT.1",ITEM_COMPAT,1,QUERY_FUNCTION},
  120.    {(CHARTYPE *)"CURLINE.0",ITEM_CURLINE,0,QUERY_FUNCTION},
  121.    {(CHARTYPE *)"CURLINE.1",ITEM_CURLINE,1,QUERY_FUNCTION},
  122.    {(CHARTYPE *)"CURLINE.2",ITEM_CURLINE,2,QUERY_FUNCTION},
  123.    {(CHARTYPE *)"CURLINE.3",ITEM_CURLINE,3,QUERY_FUNCTION},
  124.    {(CHARTYPE *)"CURSOR.0",ITEM_CURSOR,0,QUERY_FUNCTION},
  125.    {(CHARTYPE *)"CURSOR.1",ITEM_CURSOR,1,QUERY_FUNCTION},
  126.    {(CHARTYPE *)"CURSOR.2",ITEM_CURSOR,2,QUERY_FUNCTION},
  127.    {(CHARTYPE *)"CURSOR.3",ITEM_CURSOR,3,QUERY_FUNCTION},
  128.    {(CHARTYPE *)"CURSOR.4",ITEM_CURSOR,4,QUERY_FUNCTION},
  129.    {(CHARTYPE *)"CURSOR.5",ITEM_CURSOR,5,QUERY_FUNCTION},
  130.    {(CHARTYPE *)"CURSOR.6",ITEM_CURSOR,6,QUERY_FUNCTION},
  131.    {(CHARTYPE *)"CURSOR.7",ITEM_CURSOR,7,QUERY_FUNCTION},
  132.    {(CHARTYPE *)"CURSOR.8",ITEM_CURSOR,8,QUERY_FUNCTION},
  133.    {(CHARTYPE *)"DIRFILEID.0",ITEM_DIRFILEID,0,QUERY_FUNCTION},
  134.    {(CHARTYPE *)"DIRFILEID.1",ITEM_DIRFILEID,1,QUERY_FUNCTION},
  135.    {(CHARTYPE *)"DIRFILEID.2",ITEM_DIRFILEID,2,QUERY_FUNCTION},
  136.    {(CHARTYPE *)"DISPLAY.0",ITEM_DISPLAY,0,QUERY_FUNCTION},
  137.    {(CHARTYPE *)"DISPLAY.1",ITEM_DISPLAY,1,QUERY_FUNCTION},
  138.    {(CHARTYPE *)"DISPLAY.2",ITEM_DISPLAY,2,QUERY_FUNCTION},
  139.    {(CHARTYPE *)"EOF.0",ITEM_EOF,0,QUERY_FUNCTION},
  140.    {(CHARTYPE *)"EOF.1",ITEM_EOF,1,QUERY_FUNCTION},
  141.    {(CHARTYPE *)"EOLOUT.0",ITEM_EOLOUT,0,QUERY_FUNCTION},
  142.    {(CHARTYPE *)"EOLOUT.1",ITEM_EOLOUT,1,QUERY_FUNCTION},
  143.    {(CHARTYPE *)"ETMODE.0",ITEM_ETMODE,0,QUERY_FUNCTION},
  144.    {(CHARTYPE *)"ETMODE.1",ITEM_ETMODE,1,QUERY_FUNCTION},
  145.    {(CHARTYPE *)"FNAME.0",ITEM_FNAME,0,QUERY_FUNCTION},
  146.    {(CHARTYPE *)"FNAME.1",ITEM_FNAME,1,QUERY_FUNCTION},
  147.    {(CHARTYPE *)"FPATH.0",ITEM_FPATH,0,QUERY_FUNCTION},
  148.    {(CHARTYPE *)"FPATH.1",ITEM_FPATH,1,QUERY_FUNCTION},
  149.    {(CHARTYPE *)"FTYPE.0",ITEM_FTYPE,0,QUERY_FUNCTION},
  150.    {(CHARTYPE *)"FTYPE.1",ITEM_FTYPE,1,QUERY_FUNCTION},
  151.    {(CHARTYPE *)"GETENV.0",ITEM_GETENV,0,QUERY_FUNCTION},
  152.    {(CHARTYPE *)"GETENV.1",ITEM_GETENV,1,QUERY_FUNCTION},
  153.    {(CHARTYPE *)"HEX.0",ITEM_HEX,0,QUERY_FUNCTION},
  154.    {(CHARTYPE *)"HEX.1",ITEM_HEX,1,QUERY_FUNCTION},
  155.    {(CHARTYPE *)"HEXDISPLAY.0",ITEM_HEXDISPLAY,0,QUERY_FUNCTION},
  156.    {(CHARTYPE *)"HEXDISPLAY.1",ITEM_HEXDISPLAY,1,QUERY_FUNCTION},
  157.    {(CHARTYPE *)"HEXSHOW.0",ITEM_HEXSHOW,0,QUERY_FUNCTION},
  158.    {(CHARTYPE *)"HEXSHOW.1",ITEM_HEXSHOW,1,QUERY_FUNCTION},
  159.    {(CHARTYPE *)"HEXSHOW.2",ITEM_HEXSHOW,2,QUERY_FUNCTION},
  160.    {(CHARTYPE *)"IDLINE.0",ITEM_IDLINE,0,QUERY_FUNCTION},
  161.    {(CHARTYPE *)"IDLINE.1",ITEM_IDLINE,1,QUERY_FUNCTION},
  162.    {(CHARTYPE *)"IMPMACRO.0",ITEM_IMPMACRO,0,QUERY_FUNCTION},
  163.    {(CHARTYPE *)"IMPMACRO.1",ITEM_IMPMACRO,1,QUERY_FUNCTION},
  164.    {(CHARTYPE *)"IMPMOS.0",ITEM_IMPOS,0,QUERY_FUNCTION},
  165.    {(CHARTYPE *)"IMPMOS.1",ITEM_IMPOS,1,QUERY_FUNCTION},
  166.    {(CHARTYPE *)"INSERTMODE.0",ITEM_INSERTMODE,0,QUERY_FUNCTION},
  167.    {(CHARTYPE *)"INSERTMODE.1",ITEM_INSERTMODE,1,QUERY_FUNCTION},
  168.    {(CHARTYPE *)"LASTMSG.0",ITEM_LASTMSG,0,QUERY_FUNCTION},
  169.    {(CHARTYPE *)"LASTMSG.1",ITEM_LASTMSG,1,QUERY_FUNCTION},
  170.    {(CHARTYPE *)"LASTRC.0",ITEM_LASTRC,0,QUERY_FUNCTION},
  171.    {(CHARTYPE *)"LASTRC.1",ITEM_LASTRC,1,QUERY_FUNCTION},
  172.    {(CHARTYPE *)"LENGTH.0",ITEM_LENGTH,0,QUERY_FUNCTION},
  173.    {(CHARTYPE *)"LENGTH.1",ITEM_LENGTH,1,QUERY_FUNCTION},
  174.    {(CHARTYPE *)"LINE.0",ITEM_LINE,0,QUERY_FUNCTION},
  175.    {(CHARTYPE *)"LINE.1",ITEM_LINE,1,QUERY_FUNCTION},
  176.    {(CHARTYPE *)"LINEND.0",ITEM_LINEND,0,QUERY_FUNCTION},
  177.    {(CHARTYPE *)"LINEND.1",ITEM_LINEND,1,QUERY_FUNCTION},
  178.    {(CHARTYPE *)"LINEND.2",ITEM_LINEND,2,QUERY_FUNCTION},
  179.    {(CHARTYPE *)"MACROEXT.0",ITEM_MACROEXT,0,QUERY_FUNCTION},
  180.    {(CHARTYPE *)"MACROEXT.1",ITEM_MACROEXT,1,QUERY_FUNCTION},
  181.    {(CHARTYPE *)"MACROPATH.0",ITEM_MACROPATH,0,QUERY_FUNCTION},
  182.    {(CHARTYPE *)"MACROPATH.1",ITEM_MACROPATH,1,QUERY_FUNCTION},
  183.    {(CHARTYPE *)"MARGINS.0",ITEM_MARGINS,0,QUERY_FUNCTION},
  184.    {(CHARTYPE *)"MARGINS.1",ITEM_MARGINS,1,QUERY_FUNCTION},
  185.    {(CHARTYPE *)"MARGINS.2",ITEM_MARGINS,2,QUERY_FUNCTION},
  186.    {(CHARTYPE *)"MARGINS.3",ITEM_MARGINS,3,QUERY_FUNCTION},
  187.    {(CHARTYPE *)"MONITOR.0",ITEM_MONITOR,0,QUERY_FUNCTION},
  188.    {(CHARTYPE *)"MONITOR.1",ITEM_MONITOR,1,QUERY_FUNCTION},
  189.    {(CHARTYPE *)"MONITOR.2",ITEM_MONITOR,2,QUERY_FUNCTION},
  190.    {(CHARTYPE *)"MSGLINE.0",ITEM_MSGLINE,0,QUERY_FUNCTION},
  191.    {(CHARTYPE *)"MSGLINE.1",ITEM_MSGLINE,1,QUERY_FUNCTION},
  192.    {(CHARTYPE *)"MSGLINE.2",ITEM_MSGLINE,2,QUERY_FUNCTION},
  193.    {(CHARTYPE *)"MSGLINE.3",ITEM_MSGLINE,3,QUERY_FUNCTION},
  194.    {(CHARTYPE *)"MSGLINE.4",ITEM_MSGLINE,4,QUERY_FUNCTION},
  195.    {(CHARTYPE *)"MSGMODE.0",ITEM_MSGMODE,0,QUERY_FUNCTION},
  196.    {(CHARTYPE *)"MSGMODE.1",ITEM_MSGMODE,1,QUERY_FUNCTION},
  197.    {(CHARTYPE *)"NBFILE.0",ITEM_NBFILE,0,QUERY_FUNCTION},
  198.    {(CHARTYPE *)"NBFILE.1",ITEM_NBFILE,1,QUERY_FUNCTION},
  199.    {(CHARTYPE *)"NEWLINES.0",ITEM_NEWLINES,0,QUERY_FUNCTION},
  200.    {(CHARTYPE *)"NEWLINES.1",ITEM_NEWLINES,1,QUERY_FUNCTION},
  201.    {(CHARTYPE *)"NONDISP.0",ITEM_NONDISP,0,QUERY_FUNCTION},
  202.    {(CHARTYPE *)"NONDISP.1",ITEM_NONDISP,1,QUERY_FUNCTION},
  203.    {(CHARTYPE *)"NUMBER.0",ITEM_NUMBER,0,QUERY_FUNCTION},
  204.    {(CHARTYPE *)"NUMBER.1",ITEM_NUMBER,1,QUERY_FUNCTION},
  205.    {(CHARTYPE *)"POSITION.0",ITEM_POSITION,0,QUERY_FUNCTION},
  206.    {(CHARTYPE *)"POSITION.1",ITEM_POSITION,1,QUERY_FUNCTION},
  207.    {(CHARTYPE *)"POSITION.2",ITEM_POSITION,2,QUERY_FUNCTION},
  208.    {(CHARTYPE *)"POSITION.3",ITEM_POSITION,3,QUERY_FUNCTION},
  209.    {(CHARTYPE *)"PREFIX.0",ITEM_PREFIX,0,QUERY_FUNCTION},
  210.    {(CHARTYPE *)"PREFIX.1",ITEM_PREFIX,1,QUERY_FUNCTION},
  211.    {(CHARTYPE *)"PREFIX.2",ITEM_PREFIX,2,QUERY_FUNCTION},
  212.    {(CHARTYPE *)"PRINTER.0",ITEM_PRINTER,0,QUERY_FUNCTION},
  213.    {(CHARTYPE *)"PRINTER.1",ITEM_PRINTER,1,QUERY_FUNCTION},
  214.    {(CHARTYPE *)"REPROFILE.0",ITEM_REPROFILE,0,QUERY_FUNCTION},
  215.    {(CHARTYPE *)"REPROFILE.1",ITEM_REPROFILE,1,QUERY_FUNCTION},
  216.    {(CHARTYPE *)"RESERVED.0",ITEM_RESERVED,0,QUERY_FUNCTION},
  217.    {(CHARTYPE *)"RESERVED.1",ITEM_RESERVED,1,QUERY_FUNCTION},
  218.    {(CHARTYPE *)"REXXOUTPUT.0",ITEM_REXXOUTPUT,0,QUERY_FUNCTION},
  219.    {(CHARTYPE *)"REXXOUTPUT.1",ITEM_REXXOUTPUT,1,QUERY_FUNCTION},
  220.    {(CHARTYPE *)"REXXOUTPUT.2",ITEM_REXXOUTPUT,2,QUERY_FUNCTION},
  221.    {(CHARTYPE *)"SCALE.0",ITEM_SCALE,0,QUERY_FUNCTION},
  222.    {(CHARTYPE *)"SCALE.1",ITEM_SCALE,1,QUERY_FUNCTION},
  223.    {(CHARTYPE *)"SCALE.2",ITEM_SCALE,2,QUERY_FUNCTION},
  224.    {(CHARTYPE *)"SCOPE.0",ITEM_SCOPE,0,QUERY_FUNCTION},
  225.    {(CHARTYPE *)"SCOPE.1",ITEM_SCOPE,1,QUERY_FUNCTION},
  226.    {(CHARTYPE *)"SELECT.0",ITEM_SELECT,0,QUERY_FUNCTION},
  227.    {(CHARTYPE *)"SELECT.1",ITEM_SELECT,1,QUERY_FUNCTION},
  228.    {(CHARTYPE *)"SELECT.2",ITEM_SELECT,2,QUERY_FUNCTION},
  229.    {(CHARTYPE *)"SHADOW.0",ITEM_SHADOW,0,QUERY_FUNCTION},
  230.    {(CHARTYPE *)"SHADOW.1",ITEM_SHADOW,1,QUERY_FUNCTION},
  231.    {(CHARTYPE *)"SIZE.0",ITEM_SIZE,0,QUERY_FUNCTION},
  232.    {(CHARTYPE *)"SIZE.1",ITEM_SIZE,1,QUERY_FUNCTION},
  233.    {(CHARTYPE *)"STATUSLINE.0",ITEM_STATUSLINE,0,QUERY_FUNCTION},
  234.    {(CHARTYPE *)"STATUSLINE.1",ITEM_STATUSLINE,1,QUERY_FUNCTION},
  235.    {(CHARTYPE *)"STAY.0",ITEM_STAY,0,QUERY_FUNCTION},
  236.    {(CHARTYPE *)"STAY.1",ITEM_STAY,1,QUERY_FUNCTION},
  237.    {(CHARTYPE *)"TABKEY.0",ITEM_TABKEY,0,QUERY_FUNCTION},
  238.    {(CHARTYPE *)"TABKEY.1",ITEM_TABKEY,1,QUERY_FUNCTION},
  239.    {(CHARTYPE *)"TABKEY.2",ITEM_TABKEY,2,QUERY_FUNCTION},
  240.    {(CHARTYPE *)"TABLINE.0",ITEM_TABLINE,0,QUERY_FUNCTION},
  241.    {(CHARTYPE *)"TABLINE.1",ITEM_TABLINE,1,QUERY_FUNCTION},
  242.    {(CHARTYPE *)"TABLINE.2",ITEM_TABLINE,2,QUERY_FUNCTION},
  243.    {(CHARTYPE *)"TABS.0",ITEM_TABS,0,QUERY_FUNCTION},
  244.    {(CHARTYPE *)"TABS.1",ITEM_TABS,1,QUERY_FUNCTION},
  245.    {(CHARTYPE *)"TABSIN.0",ITEM_TABSIN,0,QUERY_FUNCTION},
  246.    {(CHARTYPE *)"TABSIN.1",ITEM_TABSIN,1,QUERY_FUNCTION},
  247.    {(CHARTYPE *)"TABSIN.2",ITEM_TABSIN,2,QUERY_FUNCTION},
  248.    {(CHARTYPE *)"TABSOUT.0",ITEM_TABSOUT,0,QUERY_FUNCTION},
  249.    {(CHARTYPE *)"TABSOUT.1",ITEM_TABSOUT,1,QUERY_FUNCTION},
  250.    {(CHARTYPE *)"TABSOUT.2",ITEM_TABSOUT,2,QUERY_FUNCTION},
  251.    {(CHARTYPE *)"TERMINAL.0",ITEM_TERMINAL,0,QUERY_FUNCTION},
  252.    {(CHARTYPE *)"TERMINAL.1",ITEM_TERMINAL,1,QUERY_FUNCTION},
  253.    {(CHARTYPE *)"TOF.0",ITEM_TOF,0,QUERY_FUNCTION},
  254.    {(CHARTYPE *)"TOF.1",ITEM_TOF,1,QUERY_FUNCTION},
  255.    {(CHARTYPE *)"VERIFY.0",ITEM_VERIFY,0,QUERY_FUNCTION},
  256.    {(CHARTYPE *)"VERIFY.1",ITEM_VERIFY,1,QUERY_FUNCTION},
  257.    {(CHARTYPE *)"VERSHIFT.0",ITEM_VERSHIFT,0,QUERY_FUNCTION},
  258.    {(CHARTYPE *)"VERSHIFT.1",ITEM_VERSHIFT,1,QUERY_FUNCTION},
  259.    {(CHARTYPE *)"VERSION.0",ITEM_VERSION,0,QUERY_FUNCTION},
  260.    {(CHARTYPE *)"VERSION.1",ITEM_VERSION,1,QUERY_FUNCTION},
  261.    {(CHARTYPE *)"VERSION.2",ITEM_VERSION,2,QUERY_FUNCTION},
  262.    {(CHARTYPE *)"VERSION.3",ITEM_VERSION,3,QUERY_FUNCTION},
  263.    {(CHARTYPE *)"VERSION.4",ITEM_VERSION,4,QUERY_FUNCTION},
  264.    {(CHARTYPE *)"WIDTH.0",ITEM_WIDTH,0,QUERY_FUNCTION},
  265.    {(CHARTYPE *)"WIDTH.1",ITEM_WIDTH,1,QUERY_FUNCTION},
  266.    {(CHARTYPE *)"WORDWRAP.0",ITEM_WORDWRAP,0,QUERY_FUNCTION},
  267.    {(CHARTYPE *)"WORDWRAP.1",ITEM_WORDWRAP,1,QUERY_FUNCTION},
  268.    {(CHARTYPE *)"ZONE.0",ITEM_ZONE,0,QUERY_FUNCTION},
  269.    {(CHARTYPE *)"ZONE.1",ITEM_ZONE,1,QUERY_FUNCTION},
  270.    {(CHARTYPE *)"ZONE.2",ITEM_ZONE,2,QUERY_FUNCTION},
  271.    {(CHARTYPE *)"AFTER",ITEM_AFTER_FUNCTION,1,QUERY_FUNCTION},
  272.    {(CHARTYPE *)"BEFORE",ITEM_BEFORE_FUNCTION,1,QUERY_FUNCTION},
  273.    {(CHARTYPE *)"BLANK",ITEM_BLANK_FUNCTION,1,QUERY_FUNCTION},
  274.    {(CHARTYPE *)"BLOCK",ITEM_BLOCK_FUNCTION,1,QUERY_FUNCTION},
  275.    {(CHARTYPE *)"BOTTOMEDGE",ITEM_BOTTOMEDGE_FUNCTION,1,QUERY_FUNCTION},
  276.    {(CHARTYPE *)"COMMAND",ITEM_COMMAND_FUNCTION,1,QUERY_FUNCTION},
  277.    {(CHARTYPE *)"CURRENT",ITEM_CURRENT_FUNCTION,1,QUERY_FUNCTION},
  278.    {(CHARTYPE *)"DIR",ITEM_DIR_FUNCTION,1,QUERY_FUNCTION},
  279.    {(CHARTYPE *)"END",ITEM_END_FUNCTION,1,QUERY_FUNCTION},
  280.    {(CHARTYPE *)"EOF",ITEM_EOF_FUNCTION,1,QUERY_FUNCTION},
  281.    {(CHARTYPE *)"FIRST",ITEM_FIRST_FUNCTION,1,QUERY_FUNCTION},
  282.    {(CHARTYPE *)"FOCUSEOF",ITEM_FOCUSEOF_FUNCTION,1,QUERY_FUNCTION},
  283.    {(CHARTYPE *)"FOCUSTOF",ITEM_FOCUSTOF_FUNCTION,1,QUERY_FUNCTION},
  284.    {(CHARTYPE *)"INBLOCK",ITEM_INBLOCK_FUNCTION,1,QUERY_FUNCTION},
  285.    {(CHARTYPE *)"INCOMMAND",ITEM_INCOMMAND_FUNCTION,1,QUERY_FUNCTION},
  286.    {(CHARTYPE *)"INITIAL",ITEM_INITIAL_FUNCTION,1,QUERY_FUNCTION},
  287.    {(CHARTYPE *)"INPREFIX",ITEM_INPREFIX_FUNCTION,1,QUERY_FUNCTION},
  288.    {(CHARTYPE *)"LEFTEDGE",ITEM_LEFTEDGE_FUNCTION,1,QUERY_FUNCTION},
  289.    {(CHARTYPE *)"MODIFIABLE",ITEM_MODIFIABLE_FUNCTION,1,QUERY_FUNCTION},
  290.    {(CHARTYPE *)"RIGHTEDGE",ITEM_RIGHTEDGE_FUNCTION,1,QUERY_FUNCTION},
  291.    {(CHARTYPE *)"SPACECHAR",ITEM_SPACECHAR_FUNCTION,1,QUERY_FUNCTION},
  292.    {(CHARTYPE *)"TOF",ITEM_TOF_FUNCTION,1,QUERY_FUNCTION},
  293.    {(CHARTYPE *)"TOPEDGE",ITEM_TOPEDGE_FUNCTION,1,QUERY_FUNCTION},
  294.    {(CHARTYPE *)"VERONE",ITEM_VERONE_FUNCTION,1,QUERY_FUNCTION},
  295.    {(CHARTYPE *)"VALID_TARGET",ITEM_VALID_TARGET_FUNCTION,1,QUERY_FUNCTION},
  296.    {NULL,0,0,0},
  297.   };
  298.  
  299. /***********************************************************************/
  300. #if defined(USE_AIXREXX)
  301. LONG THE_Commands(
  302.    PRXSTRING Command,    /* Command string passed from the caller    */
  303.    PUSHORT   Flags,      /* pointer to short for return of flags     */
  304.    PRXSTRING Retstr)     /* pointer to RXSTRING for RC return        */
  305. #else
  306. ULONG THE_Commands(
  307.    PRXSTRING Command,    /* Command string passed from the caller    */
  308.    PUSHORT   Flags,      /* pointer to short for return of flags     */
  309.    PRXSTRING Retstr)     /* pointer to RXSTRING for RC return        */
  310. #endif
  311. /***********************************************************************/
  312. {
  313. /*-------------------------- external data ----------------------------*/
  314.  extern CHARTYPE *temp_cmd;
  315. /*--------------------------- local data ------------------------------*/
  316.  short rc=RC_OK;
  317.  SHVBLOCK shv;
  318.  RXSTRING argstr;
  319. /*--------------------------- processing ------------------------------*/
  320.  if (allocate_temp_space(Command->strlength,TEMP_TEMP_CMD) != RC_OK)
  321.    {
  322.     display_error(30,(CHARTYPE *)"",FALSE);
  323.     *Flags = RXSUBCOM_ERROR;             /* raise an error condition   */
  324.     sprintf(Retstr->strptr, "%d", rc);   /* format return code string  */
  325.                                          /* and set the correct length */
  326.     Retstr->strlength = strlen(Retstr->strptr);
  327.     return 0L;                           /* processing completed       */
  328.    }
  329.  memcpy(temp_cmd,Command->strptr,Command->strlength);
  330.  temp_cmd[Command->strlength] = '\0';
  331.  
  332.  if (strcmp("XXYYZZ",temp_cmd) == 0)
  333.    {
  334.     shv.shvnext=NULL;                                /* only one block */
  335.     shv.shvcode=RXSHV_NEXTV;                             /* direct set */
  336.  
  337.     argstr.strptr=NULL;
  338.     argstr.strlength=0;
  339.     shv.shvname=argstr;
  340.     rc = 0;
  341.     while(rc != 2)
  342.      {
  343.       rc = RexxVariablePool(&shv);            /* get the next variable */
  344.       if (rc != 2)
  345.         {
  346.          sprintf(temp_cmd,"i <%s> <%s> <%d>",
  347.              shv.shvname.strptr,shv.shvvalue.strptr,shv.shvvalue.strlength);
  348.          command_line(temp_cmd,COMMAND_ONLY_FALSE);
  349.         }
  350.      }
  351.    }
  352.  else
  353.    rc = command_line(temp_cmd,COMMAND_ONLY_FALSE);
  354.  if (rc < 0)
  355.     *Flags = RXSUBCOM_ERROR;             /* raise an error condition   */
  356.  else
  357.     *Flags = RXSUBCOM_OK;                /* not found is not an error  */
  358.  
  359.  sprintf(Retstr->strptr, "%d", rc);      /* format return code string  */
  360.                                          /* and set the correct length */
  361.  Retstr->strlength = strlen(Retstr->strptr);
  362.  return 0L;                              /* processing completed       */
  363. }
  364. /***********************************************************************/
  365. LONG THE_Exit_Handler(
  366.       LONG  ExitNumber,    /* code defining the exit function    */
  367.       LONG  Subfunction,   /* code defining the exit subfunction */
  368.       PEXIT ParmBlock)     /* function dependent control block   */
  369. /***********************************************************************/
  370. {
  371. /*-------------------------- external data ----------------------------*/
  372.  extern WINDOW *foot;
  373.  extern bool in_profile;
  374.  extern CHARTYPE *temp_cmd;
  375.  extern CHARTYPE rexx_filename[10];
  376.  extern CHARTYPE rexx_pathname[MAX_FILE_NAME+1];
  377.  extern LINETYPE CAPREXXMAXx;
  378.  extern bool CAPREXXOUTx;
  379.  extern bool rexx_output;
  380. /*--------------------------- local data ------------------------------*/
  381.  RXSIOTRC_PARM *trc_parm = (RXSIOTRC_PARM *)ParmBlock;
  382.  LONG rc=0L;
  383.  register int i=0;
  384. /*--------------------------- processing ------------------------------*/
  385.  if (Subfunction != RXSIOSAY   /* ignore all but RXSIOSAY and RXSIOTRC */
  386.  &&  Subfunction != RXSIOTRC)
  387.     return(RXEXIT_NOT_HANDLED);
  388. /*---------------------------------------------------------------------*/
  389. /* If this is the first time this exit handler is called, set up the   */
  390. /* handling of the result; either open the capture file, or set the    */
  391. /* terminal out of curses mode so scrolling etc. work.                 */
  392. /*---------------------------------------------------------------------*/
  393.  if (!rexx_output)
  394.    {
  395.     rexx_output = TRUE;
  396.     if (CAPREXXOUTx)
  397.       {
  398.        strcpy(temp_cmd,rexx_pathname);
  399.        strcat(temp_cmd,rexx_filename);
  400.        rexxoutfp = fopen(temp_cmd,"w");
  401.       }
  402.     else
  403.       {
  404.        if (!in_profile)
  405.          {
  406.           wmove(foot,0,COLS-1);
  407.           wrefresh(foot);
  408.           suspend_curses();
  409.          }
  410.        printf("\n");                       /* scroll the screen 1 line */
  411.        fflush(stdout);
  412.       }
  413.    }
  414. /*---------------------------------------------------------------------*/
  415. /* If the REXX interpreter has been halted by line limit exceeded, just*/
  416. /* return to the interpreter indicating that THE is hadnling the output*/
  417. /* of messages. This is done to stop the "cluter" that comes back as   */
  418. /* the interpreter tries to tell us that it is stopping.               */
  419. /*---------------------------------------------------------------------*/
  420.  if (rexx_halted)
  421.     return(RXEXIT_HANDLED);
  422. /*---------------------------------------------------------------------*/
  423. /* If we are capturing the rexx output, print the string to the file.  */
  424. /*---------------------------------------------------------------------*/
  425.  if (CAPREXXOUTx)
  426.    {
  427.     for (i=0;i<trc_parm->rxsio_string.strlength;i++)
  428.        fputc(trc_parm->rxsio_string.strptr[i],rexxoutfp);
  429.     fputc('\n',rexxoutfp);
  430. /*    fprintf(rexxoutfp,"%s\n",trc_parm->rxsio_string.strptr); */
  431.     rc = RXEXIT_HANDLED;
  432.    }
  433.  else
  434.     rc = RXEXIT_NOT_HANDLED;
  435. /*---------------------------------------------------------------------*/
  436. /* If the number of lines processed exceeds the line limit, display our*/
  437. /* own message telling what has happened and exit with                 */
  438. /* RXEXIT_RAISE_ERROR. This tells the interpreter that it is to stop.  */
  439. /*---------------------------------------------------------------------*/
  440.  if (++captured_lines > CAPREXXMAXx)
  441.    {
  442.     if (CAPREXXOUTx)
  443.        fprintf(rexxoutfp,"THE: REXX macro halted - line limit (%d) exceeded\n",CAPREXXMAXx);
  444.     else
  445.        printf("THE: REXX macro halted - line limit (%d) exceeded\n",CAPREXXMAXx);
  446.     rc = RXEXIT_RAISE_ERROR;
  447.     rexx_halted = TRUE;
  448.    }
  449.  return(rc);
  450. }
  451. /***********************************************************************/
  452. #if defined(USE_AIXREXX)
  453. USHORT THE_Function_Handler(
  454.       PSZ   FunctionName,  /* name of function */
  455.       ULONG Argc,          /* number of arguments    */
  456.       RXSTRING Argv[],     /* array of arguments in RXSTRINGs */
  457.       PSZ   QueueName,     /* name of queue */
  458.       PRXSTRING Retstr)    /* return string   */
  459. #else
  460. ULONG  THE_Function_Handler(
  461. #  if defined(EMX)
  462.       PCSZ   FunctionName,  /* name of function */
  463.       ULONG Argc,          /* number of arguments    */
  464.       RXSTRING Argv[],     /* array of arguments in RXSTRINGs */
  465.       PCSZ   QueueName,     /* name of queue */
  466.       PRXSTRING Retstr)    /* return string   */
  467. #  else
  468.       PSZ   FunctionName,  /* name of function */
  469.       ULONG Argc,          /* number of arguments    */
  470.       RXSTRING Argv[],     /* array of arguments in RXSTRINGs */
  471.       PSZ   QueueName,     /* name of queue */
  472.       PRXSTRING Retstr)    /* return string   */
  473. #  endif
  474. #endif
  475. /***********************************************************************/
  476. {
  477. /*-------------------------- external data ----------------------------*/
  478.  extern VALUE item_values[MAX_VARIABLES_RETURNED];
  479. /*--------------------------- local data ------------------------------*/
  480.  register short i=0;
  481. /*--------------------------- processing ------------------------------*/
  482. /*---------------------------------------------------------------------*/
  483. /* Find the external function name in the array. Error if not found.   */
  484. /*---------------------------------------------------------------------*/
  485.  for (i=0;function_item[i].name != NULL;i++)
  486.    {
  487.     if (memcmpi(FunctionName,function_item[i].name,strlen(function_item[i].name))==0)
  488.       {
  489.        (void)get_item_values(function_item[i].item_number,"",function_item[i].query,(LINETYPE)Argc,Argv[0].strptr,(LINETYPE)Argv[0].strlength);
  490.        if (item_values[function_item[i].item_index].len > 256)
  491.          {
  492.           if ((Retstr->strptr = (PSZ)(*the_malloc)(item_values[function_item[i].item_index].len)) == NULL)
  493.             {
  494.              display_error(30,(CHARTYPE *)"",FALSE);
  495.              return(1);
  496.             }
  497.          }
  498.        memcpy(Retstr->strptr,item_values[function_item[i].item_index].value,
  499.                              item_values[function_item[i].item_index].len);
  500.        Retstr->strlength = item_values[function_item[i].item_index].len;
  501.        return(0);
  502.       }
  503.    }
  504.  return(1);                                    /* fatal error for REXX */
  505. }
  506. /***********************************************************************/
  507. short initialise_rexx(void)
  508. /***********************************************************************/
  509. {
  510. /*--------------------------- local data ------------------------------*/
  511.  APIRET rc;
  512.  register short i=0;
  513. /*--------------------------- processing ------------------------------*/
  514. #ifdef TRACE
  515.  trace_function("rexx.c:    initialise_rexx");
  516. #endif
  517.  
  518. #if defined(MSWIN)
  519.  if (RexxThread(GetCurrentTask(),THREAD_ATTACH) != THREAD_ATTACH_AOK)
  520.     return(RC_INVALID_ENVIRON);
  521. #endif
  522.  
  523. #if defined(USE_AIXREXX)
  524.  rc = RexxRegisterSubcom((PSZ)"THE",
  525.                          (PRXSUBCOM)&THE_Commands,
  526.                          (PUCHAR)NULL);
  527. #else
  528.  rc = RexxRegisterSubcomExe((PSZ)"THE",
  529.                            (PFN)&THE_Commands,
  530.                            (PUCHAR)NULL);
  531. #endif
  532.  
  533.  if (rc != RXSUBCOM_OK)
  534.     return((short)rc);
  535.  
  536. #if !defined(USE_AIXREXX)
  537.  rc = RexxRegisterExitExe((PSZ)"THE_EXIT",
  538.                           (PFN)&THE_Exit_Handler,
  539.                           (PUCHAR)NULL);
  540.  if (rc != RXEXIT_OK)
  541.     return((short)rc);
  542. #endif
  543.  
  544.  for (i=0;function_item[i].name != NULL;i++)
  545.    {
  546. #if defined(USE_AIXREXX)
  547.     rc = RexxRegisterFunction((PSZ)function_item[i].name,
  548.                               (PRXFUNC)&THE_Function_Handler,NULL);
  549. #else
  550.     rc = RexxRegisterFunctionExe((PSZ)function_item[i].name,
  551.                                  (PFN)&THE_Function_Handler);
  552. #endif
  553.     if (rc != RXFUNC_OK)
  554.        return((short)rc);
  555.    }
  556.  
  557. #ifdef TRACE
  558.  trace_return();
  559. #endif
  560.  return((short)rc);
  561. }
  562. /***********************************************************************/
  563. short finalise_rexx(void)
  564. /***********************************************************************/
  565. {
  566. /*--------------------------- local data ------------------------------*/
  567.  APIRET rc;
  568.  register short i=0;
  569. /*--------------------------- processing ------------------------------*/
  570. #ifdef TRACE
  571.  trace_function("rexx.c:    finalise_rexx");
  572. #endif
  573.  
  574. #if defined(USE_AIXREXX)
  575.  rc = RexxDeregisterSubcom((PSZ)"THE");
  576. #else
  577.  rc = RexxDeregisterSubcom((PSZ)"THE",(PSZ)NULL);
  578.  rc = RexxDeregisterExit((PSZ)"THE_EXIT",(PSZ)NULL);
  579. #endif
  580.  for (i=0;function_item[i].name != NULL;i++)
  581.    {
  582.     rc = RexxDeregisterFunction((PSZ)function_item[i].name);
  583.    }
  584.  
  585. #if defined(MSWIN)
  586.  (void)RexxThread(GetCurrentTask(),THREAD_DETACH);
  587. #endif
  588.  
  589. #ifdef TRACE
  590.  trace_return();
  591. #endif
  592.  return((short)rc);
  593. }
  594.  
  595. /***********************************************************************/
  596. short execute_macro_file(CHARTYPE *filename,CHARTYPE *params)
  597. /***********************************************************************/
  598. {
  599. /*-------------------------- external data ----------------------------*/
  600.  extern WINDOW *foot;
  601.  extern bool in_profile;
  602.  extern bool error_on_screen;
  603.  extern CHARTYPE number_of_files;
  604.  extern CHARTYPE rexx_filename[10];
  605.  extern CHARTYPE rexx_pathname[MAX_FILE_NAME+1];
  606.  extern CHARTYPE *temp_cmd;
  607.  extern bool CAPREXXOUTx;
  608.  extern bool rexx_output;
  609. /*--------------------------- local data ------------------------------*/
  610. #if defined(USE_REGINA) || defined(USE_AIXREXX)
  611.  LONG rexxrc=0L;
  612. #else
  613.  USHORT rexxrc=0L;
  614. #endif
  615.  RXSTRING retstr;
  616.  RXSTRING argstr;
  617.  APIRET rc=0;
  618.  CHAR retbuf[250];
  619.  LONG num_params=0L;
  620.  CHARTYPE *rexx_args=NULL;
  621.  RXSYSEXIT exit_list[2];                /* system exit list           */
  622. /*--------------------------- processing ------------------------------*/
  623. #ifdef TRACE
  624.  trace_function("rexx.c:    execute_macro_file");
  625. #endif
  626. /*---------------------------------------------------------------------*/
  627. /* Determine how many parameters are to be passed to the interpreter.  */
  628. /* Only 0 or 1 are valid values.                                       */
  629. /*---------------------------------------------------------------------*/
  630.  if (params == NULL
  631.  || strcmp(params,"") == 0)
  632.    {
  633.     num_params = 0;
  634.     MAKERXSTRING(argstr,"",0);
  635.    }
  636.  else
  637.    {
  638.     num_params = 1;
  639.     if ((rexx_args = (CHARTYPE *)(*the_malloc)(strlen(params)+1)) == (CHARTYPE *)NULL)
  640.       {
  641.        display_error(30,(CHARTYPE *)"",FALSE);
  642. #ifdef TRACE
  643.        trace_return();
  644. #endif
  645.        return(RC_OUT_OF_MEMORY);
  646.       }
  647.     strcpy(rexx_args,params);
  648.     MAKERXSTRING(argstr,rexx_args,strlen(rexx_args));
  649.    }
  650.  
  651.  MAKERXSTRING(retstr,retbuf,sizeof(retbuf));
  652.  
  653. /*---------------------------------------------------------------------*/
  654. /* Set up pointer to REXX Exit Handler.                                */
  655. /*---------------------------------------------------------------------*/
  656. #if defined(USE_AIXREXX)
  657.  exit_list[0].sysexit_func = THE_Exit_Handler;
  658. #else
  659.  exit_list[0].sysexit_name = "THE_EXIT";
  660. #endif
  661.  exit_list[0].sysexit_code = RXSIO;
  662.  exit_list[1].sysexit_code = RXENDLST;
  663.  
  664.  captured_lines = 0L;
  665.  rexx_output = FALSE;
  666.  rexx_halted = FALSE;
  667. /*---------------------------------------------------------------------*/
  668. /* Call the REXX interpreter.                                          */
  669. /*---------------------------------------------------------------------*/
  670.  rc = RexxStart((LONG)num_params,
  671.                (PRXSTRING)&argstr,
  672.                (PSZ)filename,
  673.                (PRXSTRING)NULL,
  674.                (PSZ)"THE",
  675.                (LONG)RXCOMMAND,
  676.                (PRXSYSEXIT)exit_list,
  677. #if defined(USE_OS2REXX)
  678.                (PSHORT)&rexxrc,
  679. #else
  680.                (PLONG)&rexxrc,
  681. #endif
  682.                (PRXSTRING)&retstr);
  683.  
  684. /*---------------------------------------------------------------------*/
  685. /* Edit the captured file or clean up after REXX output displays.      */
  686. /*---------------------------------------------------------------------*/
  687.  if (rexx_output)
  688.    {
  689.     rexx_output = FALSE;
  690.     if (CAPREXXOUTx)
  691.       {
  692.        fclose(rexxoutfp);
  693.        strcpy(temp_cmd,rexx_pathname);
  694.        strcat(temp_cmd,rexx_filename);
  695.        if (!in_profile)
  696.           Xedit(temp_cmd);
  697.       }
  698.     else
  699.       {
  700.        if (in_profile)
  701.           error_on_screen = TRUE;
  702.        else
  703. /*---------------------------------------------------------------------*/
  704. /* Pause for operator intervention and restore the screen to the       */
  705. /* current screen if there are still file(s) in the ring.              */
  706. /*---------------------------------------------------------------------*/
  707.          {
  708.           printf("\n%s",HIT_ANY_KEY);
  709.           fflush(stdout);
  710.           resume_curses();
  711. /*          (void)my_getch(foot);*/
  712.           (void)my_getch(stdscr);
  713.           if (number_of_files > 0)
  714.              restore_THE();
  715.          }
  716.       }
  717.    }
  718.  
  719.  if (rexx_args != NULL)
  720.     (*the_free)(rexx_args);
  721. #ifdef TRACE
  722.  trace_return();
  723. #endif
  724.  return((short)rc);
  725. }
  726. /***********************************************************************/
  727. short set_rexx_variable(CHARTYPE *name,CHARTYPE *value,short suffix)
  728. /***********************************************************************/
  729. {
  730. /*-------------------------- external data ----------------------------*/
  731. /*--------------------------- local data ------------------------------*/
  732.  SHVBLOCK shv;
  733.  CHAR variable_name[50];
  734.  short rc=0;
  735. /*--------------------------- processing ------------------------------*/
  736. #ifdef TRACE
  737.  trace_function("rexx.c:    set_rexx_variable");
  738. #endif
  739.  
  740.  shv.shvnext=NULL;                                   /* only one block */
  741.  shv.shvcode=RXSHV_SYSET;                          /* symbolic set set */
  742. /*---------------------------------------------------------------------*/
  743. /* This calls the RexxVariablePool() function for each value. This is  */
  744. /* not the most efficient way of doing this.                           */
  745. /*---------------------------------------------------------------------*/
  746.  sprintf(variable_name,"%s.%-d",name,suffix);
  747.  make_upper(variable_name);            /* make variable name uppercase */
  748. /*---------------------------------------------------------------------*/
  749. /* Now (attempt to) set the REXX variable                              */
  750. /* Add name/value to SHVBLOCK                                          */
  751. /*---------------------------------------------------------------------*/
  752.  MAKERXSTRING(shv.shvname, variable_name, strlen(variable_name));
  753.  MAKERXSTRING(shv.shvvalue,value,strlen(value));
  754. /*---------------------------------------------------------------------*/
  755. /* One or both of these is needed, too <sigh>                          */
  756. /*---------------------------------------------------------------------*/
  757.  shv.shvnamelen=strlen(variable_name);
  758.  shv.shvvaluelen=strlen(value);
  759.  
  760. #if defined(USE_OS2REXX) || defined(USE_AIXREXX)
  761.  rc=(short)RexxVariablePool(&shv);              /* Set the REXX variable */
  762. #else
  763.  rc = RexxVariablePool(&shv);                 /* Set the REXX variable */
  764.  rc = RXSHV_OK;
  765. #endif
  766.  if (rc != RXSHV_OK 
  767.  &&  rc != RXSHV_NEWV)
  768.    {
  769.     display_error(25,(CHARTYPE *)"",FALSE);
  770.     rc = RC_SYSTEM_ERROR;
  771.    }
  772.  else
  773.     rc = RC_OK;
  774.  return(rc);
  775. }
  776. #else
  777. /*---------------------------------------------------------------------*/
  778. /* The following are dummy routines to enable the compliation of THE   */
  779. /* with a nonANSI compiler.                                            */
  780. /*---------------------------------------------------------------------*/
  781. /***********************************************************************/
  782. short initialise_rexx(void)
  783. /***********************************************************************/
  784. {
  785.  return(RC_INVALID_ENVIRON);                        /* force an error */
  786. }
  787. /***********************************************************************/
  788. short finalise_rexx(void)
  789. /***********************************************************************/
  790. {
  791.  return(RC_OK);
  792. }
  793. /***********************************************************************/
  794. short execute_macro_file(filename,params)
  795. CHARTYPE *filename;
  796. CHARTYPE *params;
  797. /***********************************************************************/
  798. {
  799.  return(RC_OK);
  800. }
  801. /***********************************************************************/
  802. short set_rexx_variable(name,value,suffix)
  803. CHARTYPE *name;
  804. CHARTYPE *value;
  805. short suffix;
  806. /***********************************************************************/
  807. {
  808.  return(RC_OK);
  809. }
  810. #endif
  811.